/**
 * 
 */
package com.carnation.qa.socketserver.proxy;

import java.lang.reflect.Method;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import com.carnation.qa.socketserver.common.util.MppContext;
import com.carnation.qa.socketserver.domain.Item;

/**
 * @author Nick
 * 
 */
public abstract class AbstractServiceImpl implements ProxyService {

	private List<Item> items;

	/**
	 * @return the items
	 */
	protected List<Item> getItems() {
		return items;
	}

	public AbstractServiceImpl(final List<Item> items) {
		this.items = items;
	}

	/**
	 * 获取方法名
	 * 
	 * @return
	 */
	protected String getMethodName(Item item) {
		try {
			String[] parts = item.getLabel().split("\\.");
			return parts[parts.length - 1];
		} catch (Exception e) {
			throw new IllegalArgumentException(item.getLabel());
		}
	}

	/**
	 * 获取方法名
	 * 
	 * @return
	 */
	protected String getMethodName() {
		return getMethodName(items.get(items.size() - 1));
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.carnation.qa.socketserver.proxy.ProxyService#invoke()
	 */
	public String run() {
		return invoke();
	}

	/**
	 * 调用执行接口
	 * 
	 * @param item
	 * @return
	 */
	protected abstract String invoke();

	/**
	 * 执行某对象方法
	 * 
	 * @param owner
	 *            对象
	 * @param methodName
	 *            方法名
	 * @param args
	 *            参数
	 * @return 方法返回值
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	protected Object invokeMethod(Object owner, String methodName, Object[] args)
			throws Exception {

		Class ownerClass = owner.getClass();

		Class[] argsClass = new Class[args.length];

		for (int i = 0, j = args.length; i < j; i++) {
			argsClass[i] = args[i].getClass();
		}

		Method method = ownerClass.getMethod(methodName, argsClass);

		return method.invoke(owner, args);
	}

	/**
	 * 优先匹配双引号内的字符串
	 * 
	 * @param content
	 * @return
	 */
	protected String getString(String content) {
		return (String) getObject(content);
	}

	protected Long getLong(String content) {
		return (Long) getObject(content);
	}

	protected Integer getInteger(String content) {
		return (Integer) getObject(content);
	}

	protected Boolean getBoolean(String content) {
		return (Boolean) getObject(content);
	}

	protected Date getDate(String content) {
		return (Date) getObject(content);
	}

	/**
	 * 将字符串转换为相应的对象
	 * 
	 * @param content
	 * @return
	 */
	protected Object getObject(String content) {
		Matcher m = Pattern.compile("\"(.*)\"").matcher(content);
		if (m.find()) {
			// 返回字符串
			return m.group(1);
		} else {
			if (content.equals("null")) {
				return null;
			} else {
				try {
					// 返回日期
					return new SimpleDateFormat(MppContext.getDateFormat())
							.parse(content);
				} catch (ParseException e) {
					try {
						// 返回整型
						return Integer.parseInt(content);
					} catch (NumberFormatException e1) {
						// 返回长整形
						if (content.endsWith("L")) {
							return Long.parseLong(content.substring(0, content
									.length() - 1));
						} else {
							try {
								// 返回双精度
								return Double.parseDouble(content);
							} catch (NumberFormatException e2) {
								// 返回布尔值
								if (content.equals("true")) {
									return true;
								}
								if (content.equals("false")) {
									return false;
								}
								throw new IllegalArgumentException(content);
							}
						}
					}
				}
			}
		}
	}
}
